import { Edge, Main as M, Node } from "pack-antv-x6"
import { ref } from "vue";
import useEvent from "./plugins/useEvent";
import NLEl from "./components/nodelist.vue"

export default class Main extends M {
    constructor() {
        super();
        //
        this.nodelist.setNodeListEl(NLEl);
        this.toolbar.reset({edge:false,layout:false,switch:false})
        //
        this.graph.resetOptions({
            connecting: {
                allowMulti: true,
                router: {
                    name: 'er',
                    args: {
                        offset: 15,
                        direction: 'H',
                    },
                },
                // validateConnection: () => true,
                validateMagnet({ magnet }) {
                    // 事实表连接桩无法创建连线
                    const port = magnet.parentElement?.getAttribute('port') || ''
                    return !/^in/.test(port)
                  },
                validateConnection({
                    sourceCell,
                    targetCell,
                    sourceMagnet,
                    targetMagnet,
                    edge
                  }) {
                    const spgs = sourceMagnet?.getAttribute('port')?.split('.')
                    // 
                    const tpgs = targetMagnet?.parentElement?.getAttribute('port')?.split('.')
                    //
                    // [in|out].[name].[number]
                    // 如果没有连接桩，则不允许连线
                    if (!spgs || !tpgs) {
                      return false;
                    }
                    // 起始边规则
                    if (['in','0'].includes(spgs[0])) {
                      return false;
                    }
                    // 目标边规则
                    if (['out','0'].includes(tpgs[0])) {
                      return false;
                    }
                    // 耦合规则 类型判断 当起始连接桩限定了类型时，则只有特定类型的连接桩才可以连接 如果 类型是 0 则标识不限制类型，可以连任意类型的连接桩或者被任意类型的连接桩连接
                    if ((spgs[1] || tpgs[1]) && spgs[1] != '0' && tpgs[1] != '0' && spgs[1] != tpgs[1]) {
                      return false;
                    }
                    const edges = this.getEdges().filter(e => e != edge);
                    const sen = edges.filter(e => e.getSourceCell() == sourceCell).length;
                    const ten = edges.filter(e => e.getTargetCell() == targetCell).length;
                    // 出边数量判断
                    if (spgs[2] && Number(spgs[2]) && sen >= Number(spgs[2])) {
                      return false;
                    }
                    // 入边数量校验
                    if (tpgs[2] && Number(tpgs[2]) && ten >= Number(tpgs[2])) {
                      return false;
                    }
              
                    return true
                  },
                // @ts-ignore
                createEdge() { return this.createEdge({ shape: 'er-edge',attrs: {
                    line: {
                        stroke: '#409EFF',
                        strokeDasharray: 5,
                        targetMarker: 'classic',
                        style: {
                            animation: 'ant-line 30s infinite linear',
                        },
                    },
                }, }) }
            },
            highlighting: {
                // 连接桩可以被连接时在连接桩外围围渲染一个包围框
                magnetAvailable: {
                    name: 'className',
                    args: {
                        className: "hightlight-available"
                    },
                },
                // 连接桩吸附连线时在连接桩外围围渲染一个包围框
                magnetAdsorbed: {
                    name: 'className',
                    args: {
                        className: "hightlight-adsorbed"
                    },
                },
            }
        })
    }
    // 是否已存在事实表
    existMainTable = ref(false);
    //
    event = useEvent(this);
    // 删除节点 主动调用
    nodeRemove(node: Node) {
        // 添加警告 或者提醒
        node.remove();
    }
    // 删除边 主动调用 edge 一定是 portedge 不会是 nodeedge
    edgeRemove(edge: Edge) {

        const sn = edge.getSourceCell() as Node;
        const tn = edge.getTargetCell() as Node;
        edge.remove();
        //
        setTimeout(() => {
            const es = this.event.getAllPortsEdge(sn, tn);
            // 判断是否还有其他 portedge 相连 ， 没有 删除节点的边
            if (es.length == 0) {
                const e = this.event.getSpecialEdge(sn, tn);
                e?.remove();
            }
        }, 0)

    }

}